#include "renderer.h"
#include <QPainter>
#include <QBrush>
#include <QPen>
#include <QDebug>
#include <QResizeEvent>  // 新增：用于窗口大小变化处理

// 初始化单元格大小（关键：避免未初始化导致的绘制异常）
Renderer::Renderer(QWidget *parent) : QWidget(parent), m_cellSize(40) {  // 初始40像素
    setMinimumSize(400, 400);
    setFocusPolicy(Qt::StrongFocus);
    // 强制背景刷新属性
    setAutoFillBackground(true);
    setBackgroundRole(QPalette::Base);  // 白色背景
    qDebug() << "Renderer 初始化完成，单元格大小：" << m_cellSize;
}

void Renderer::setMapData(const MapData &mapData) {
    m_mapData = mapData;

    // 强制修正 grid 大小：确保是 8行10列（与日志一致）
    const int TARGET_ROWS = 8;
    const int TARGET_COLS = 10;
    // 1. 修正行数：多余截断，不足补全
    m_mapData.grid.resize(TARGET_ROWS);
    // 2. 修正列数：每行列数多余截断，不足补全（补Floor=0）
    for (int row = 0; row < TARGET_ROWS; ++row) {
        m_mapData.grid[row].resize(TARGET_COLS, MapElement::Floor);
    }
    // 3. 强制修正 m_mapData 的 rows 和 cols
    m_mapData.rows = TARGET_ROWS;
    m_mapData.cols = TARGET_COLS;

    // 打印修正后的 grid 大小（验证）
    qDebug() << "=== 修正后 MapData ===";
    qDebug() << "rows:" << m_mapData.rows << "cols:" << m_mapData.cols;
    qDebug() << "grid总行数:" << m_mapData.grid.size();
    for (int row = 0; row < m_mapData.grid.size(); ++row) {
        qDebug() << "行" << row << "列数:" << m_mapData.grid[row].size();
    }

    updateCellSize();
    update();
}

// 窗口大小变化时，自动调整单元格大小（避免元素挤压/溢出）
void Renderer::resizeEvent(QResizeEvent *event) {
    QWidget::resizeEvent(event);
    updateCellSize();  // 窗口变了，单元格大小跟着变
}

// 计算合适的单元格大小（确保地图完整显示在窗口内）
void Renderer::updateCellSize() {
    if (m_mapData.rows == 0 || m_mapData.cols == 0) return;
    // 按窗口宽高和地图行列数计算最大可能的单元格大小
    int maxW = width() / m_mapData.cols;    // 按宽度分配
    int maxH = height() / m_mapData.rows;   // 按高度分配
    m_cellSize = qMin(qMax(20, qMin(maxW, maxH)), 100);  // 限制在20-100像素（合理范围）
    qDebug() << "更新单元格大小：" << m_cellSize;
}

QSize Renderer::sizeHint() const {
    if (m_mapData.rows == 0 || m_mapData.cols == 0) return QSize(400, 400);
    // 基于单元格大小返回合适的窗口大小
    return QSize(m_mapData.cols * m_cellSize, m_mapData.rows * m_cellSize);
}

void Renderer::paintEvent(QPaintEvent *event) {
    Q_UNUSED(event);
    QPainter painter(this);
    painter.setRenderHint(QPainter::Antialiasing);

    // 1. 清空整个窗口（白色底）
    painter.fillRect(rect(), Qt::white);

    // 2. 严格绘制6行10列的地图
    const int MAX_ROW = m_mapData.rows;  // 8
    const int MAX_COL = m_mapData.cols;  // 10
    for (int row = 0; row < MAX_ROW; ++row) {
        if (row >= m_mapData.grid.size()) break;
        for (int col = 0; col < MAX_COL; ++col) {
            if (col >= m_mapData.grid[row].size()) break;
            drawCell(painter, row, col, m_mapData.grid[row][col]);
        }
    }

    // 3. 绘制地图边界线（细红色，仅框住地图，不覆盖内部）
    int mapWidth = MAX_COL * m_cellSize;    // 10*80=800
    int mapHeight = MAX_ROW * m_cellSize;   // 6*80=480
    painter.setPen(QPen(Qt::red, 1));  // 线宽1像素（之前可能太宽）
    painter.setBrush(Qt::NoBrush);     // 无填充，仅线条
    painter.drawRect(0, 0, mapWidth, mapHeight);  // 边界线

    // 4. 覆盖地图外的区域（确保白色，无残留）
    if (mapWidth < width()) {
        // 覆盖右侧超出区域
        painter.fillRect(mapWidth, 0, width() - mapWidth, height(), Qt::white);
    }
    if (mapHeight < height()) {
        // 覆盖下方超出区域
        painter.fillRect(0, mapHeight, width(), height() - mapHeight, Qt::white);
    }

    // 日志验证
    QPoint playerPos = findPlayerCurrentPos();
    qDebug() << "绘制玩家位置:" << playerPos.x() << "," << playerPos.y();
}

QPoint Renderer::findPlayerCurrentPos() const {
    for (int row = 0; row < m_mapData.rows; ++row) {
        if (row >= m_mapData.grid.size()) continue;
        for (int col = 0; col < m_mapData.cols; ++col) {
            if (col >= m_mapData.grid[row].size()) continue;
            MapElement elem = m_mapData.grid[row][col];
            if (elem == MapElement::Player || elem == MapElement::PlayerOnTarget) {
                return QPoint(row, col);
            }
        }
    }
    qWarning() << "未找到玩家！";
    return QPoint(-1, -1);
}

void Renderer::drawCell(QPainter &painter, int row, int col, MapElement element) {
    int x = col * m_cellSize;
    int y = row * m_cellSize;
    QRect cellRect(x, y, m_cellSize, m_cellSize);

    // ！！关键1：每次绘制前重置画笔状态（防止继承上一个单元格的颜色）
    painter.setBrush(Qt::NoBrush);  // 取消填充
    painter.setPen(QPen(Qt::gray, 1));  // 重置画笔为网格线默认样式

    // 1. 清空单元格背景（必做，白色底）
    painter.fillRect(cellRect, Qt::white);

    // 2. 处理【地板】：只画网格线，不做任何填充
    if (element == MapElement::Floor) {
        painter.drawRect(cellRect);
        return;
    }

    // ！！关键2：严格判断“目标点底色”（只对3种情况生效，避免误判）
    bool isOnTarget = false;
    if (element == MapElement::Target ||
        element == MapElement::BoxOnTarget ||
        element == MapElement::PlayerOnTarget) {
        isOnTarget = true;
        // 绘制目标点黄色椭圆（仅椭圆区域，不覆盖整个单元格）
        painter.setBrush(Qt::yellow);
        painter.setPen(Qt::NoPen);  // 取消椭圆边框，避免与网格线重叠
        int margin = m_cellSize / 4;  // 边距放大，确保椭圆在单元格内
        painter.drawEllipse(cellRect.adjusted(margin, margin, -margin, -margin));
        // 重置画笔，避免影响后续绘制
        painter.setBrush(Qt::NoBrush);
        painter.setPen(QPen(Qt::gray, 1));
    }

    // 3. 绘制具体元素（每个元素单独设置颜色，绘制后重置）
    if (element == MapElement::Wall) {
        // 墙：深灰色填充，无边界
        painter.setBrush(Qt::darkGray);
        painter.setPen(Qt::NoPen);
        painter.fillRect(cellRect.adjusted(1, 1, -1, -1), Qt::darkGray);
    }
    else if (element == MapElement::Box) {
        // 普通箱子：蓝色方块
        painter.setBrush(Qt::blue);
        painter.setPen(Qt::NoPen);
        int margin = m_cellSize / 5;
        painter.drawRect(cellRect.adjusted(margin, margin, -margin, -margin));
    }
    else if (element == MapElement::BoxOnTarget) {
        // 箱子在目标点：深蓝色方块（覆盖黄色底色）
        painter.setBrush(Qt::darkBlue);
        painter.setPen(Qt::NoPen);
        int margin = m_cellSize / 5;
        painter.drawRect(cellRect.adjusted(margin, margin, -margin, -margin));
    }
    else if (element == MapElement::Player) {
        // 普通玩家：红色椭圆
        painter.setBrush(Qt::red);
        painter.setPen(Qt::NoPen);
        int margin = m_cellSize / 5;
        painter.drawEllipse(cellRect.adjusted(margin, margin, -margin, -margin));
    }
    else if (element == MapElement::PlayerOnTarget) {
        // 玩家在目标点：深红色椭圆（覆盖黄色底色）
        painter.setBrush(Qt::darkRed);
        painter.setPen(Qt::NoPen);
        int margin = m_cellSize / 5;
        painter.drawEllipse(cellRect.adjusted(margin, margin, -margin, -margin));
    }
    // 目标点已在前面绘制，此处无需重复

    // ！！关键3：最后绘制网格线（确保在最上层，不被元素覆盖）
    painter.setBrush(Qt::NoBrush);
    painter.setPen(QPen(Qt::gray, 1));
    painter.drawRect(cellRect);
}

void Renderer::setCellSize(int size) {
    // 限制单元格大小范围（20-100像素，避免无效值）
    m_cellSize = qMax(20, qMin(size, 100));
    qDebug() << "外部设置单元格大小为：" << m_cellSize;
    update();  // 设置后触发重绘，应用新大小
}
